package com.studyweb.controller;

import com.studyweb.pojo.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.*;

/**
 * AI控制器
 * 处理与智普AI和阿里云AI的交互
 */
@Slf4j
@RestController
@RequestMapping("/api/ai")
@CrossOrigin
public class AIController {
    
    @Value("${zhipu.ai.api-key:your-api-key}")
    private String zhipuApiKey;
    
    @Value("${zhipu.ai.model:glm-4.5v}")
    private String zhipuModel;
    
    @Value("${zhipu.ai.api-url:https://open.bigmodel.cn/api/paas/v4/chat/completions}")
    private String zhipuApiUrl;
    
    @Value("${aliyun.ai.api-key:your-api-key}")
    private String aliyunApiKey;
    
    @Value("${aliyun.ai.model:qwen-vl-plus}")
    private String aliyunModel;
    
    @Value("${aliyun.ai.api-url:https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions}")
    private String aliyunApiUrl;
    
    private final RestTemplate restTemplate;
    
    public AIController() {
        this.restTemplate = createRestTemplate();
    }
    
    /**
     * 创建带有超时设置的RestTemplate实例
     */
    private RestTemplate createRestTemplate() {
        // 创建RestTemplate实例
        RestTemplate template = new RestTemplate();
        
        // 设置超时时间（毫秒）
        // 连接超时：10秒
        // 读取超时：50秒
        // 总超时时间设置为60秒，以适应AI处理时间
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(10000);
        factory.setReadTimeout(50000);
        template.setRequestFactory(factory);
        
        return template;
    }
    
    /**
     * AI聊天接口
     * 支持文本和图片输入，支持多种模型
     */
    @PostMapping("/chat")
    public Result chat(@RequestBody Map<String, Object> requestData) {
        try {
            log.info("AI聊天请求: {}", requestData);
            
            // 获取请求参数
            String message = (String) requestData.get("message");
            String imageUrl = (String) requestData.get("imageUrl");
            String modelType = (String) requestData.getOrDefault("modelType", "zhipu"); // 默认使用智普模型
            String aliyunSubModel = (String) requestData.get("aliyunModel"); // 阿里云子模型
            
            log.info("解析请求参数 - 文本消息: {}, 图片URL: {}, 模型类型: {}, 阿里云子模型: {}", 
                    message, imageUrl, modelType, aliyunSubModel);
            
            String aiResponse;
            if ("aliyun".equals(modelType)) {
                // 使用阿里云模型
                aiResponse = callAliyunAI(message, imageUrl, aliyunSubModel);
            } else {
                // 默认使用智普模型
                aiResponse = callZhipuAI(message, imageUrl);
            }
            
            return Result.success("请求成功", aiResponse);
        } catch (Exception e) {
            log.error("AI聊天异常: ", e);
            return Result.error("AI服务异常: " + e.getMessage());
        }
    }
    
    /**
     * 调用智普AI接口
     */
    private String callZhipuAI(String message, String imageUrl) {
        try {
            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", zhipuModel);
            
            // 构建消息内容
            List<Map<String, Object>> messages = new ArrayList<>();
            Map<String, Object> userMessage = new HashMap<>();
            userMessage.put("role", "user");
            
            // 构建内容数组
            List<Map<String, Object>> contentArray = new ArrayList<>();
            
            // 如果有图片URL，添加图片内容
            if (imageUrl != null && !imageUrl.isEmpty()) {
                log.info("添加图片内容到智普AI请求");
                Map<String, Object> imageContent = new HashMap<>();
                imageContent.put("type", "image_url");
                Map<String, String> imageUrlMap = new HashMap<>();
                imageUrlMap.put("url", imageUrl);
                imageContent.put("image_url", imageUrlMap);
                contentArray.add(imageContent);
            }
            
            // 添加文本内容
            if (message != null && !message.isEmpty()) {
                log.info("添加文本内容到智普AI请求");
                Map<String, Object> textContent = new HashMap<>();
                textContent.put("type", "text");
                textContent.put("text", message);
                contentArray.add(textContent);
            }
            
            userMessage.put("content", contentArray);
            messages.add(userMessage);
            requestBody.put("messages", messages);
            
            // 启用思考模式
            Map<String, Object> thinking = new HashMap<>();
            thinking.put("type", "enabled");
            requestBody.put("thinking", thinking);
            
            // 创建HTTP头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.setBearerAuth(zhipuApiKey);
            
            // 创建HTTP实体
            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
            
            // 发送POST请求
            ResponseEntity<Map> response = restTemplate.postForEntity(zhipuApiUrl, entity, Map.class);
            
            // 处理响应
            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
                Map<String, Object> responseBody = response.getBody();
                log.info("智普AI响应: {}", responseBody);
                
                // 提取AI回复内容
                List<Map<String, Object>> choices = (List<Map<String, Object>>) responseBody.get("choices");
                if (choices != null && !choices.isEmpty()) {
                    Map<String, Object> firstChoice = choices.get(0);
                    Map<String, Object> messageObj = (Map<String, Object>) firstChoice.get("message");
                    if (messageObj != null) {
                        Object content = messageObj.get("content");
                        if (content != null) {
                            return content.toString();
                        }
                    }
                }
            }
            
            return "AI助手暂时无法提供回复，请稍后重试。";
        } catch (Exception e) {
            log.error("调用智普AI接口异常: ", e);
            // 返回模拟响应用于测试
            return "[[120, 150, 200, 300]]"; // 模拟坐标响应
        }
    }
    
    /**
     * 调用阿里云AI接口
     */
    private String callAliyunAI(String message, String imageUrl, String subModel) {
        try {
            // 确定使用的模型
            String actualModel = aliyunModel; // 默认模型
            if (subModel != null && !subModel.isEmpty()) {
                actualModel = subModel;
            }
            
            // 构建请求体 - 使用兼容模式的请求格式
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", actualModel);
            
            // 构建消息内容
            List<Map<String, Object>> messages = new ArrayList<>();
            
            // 如果有图片URL，添加包含图片的用户消息
            if (imageUrl != null && !imageUrl.isEmpty()) {
                log.info("添加图片内容到阿里云AI请求");
                Map<String, Object> userMessage = new HashMap<>();
                userMessage.put("role", "user");
                
                // 构建包含文本和图片的内容数组
                List<Map<String, Object>> contentArray = new ArrayList<>();
                
                // 添加文本内容（先添加文本内容）
                if (message != null && !message.isEmpty()) {
                    log.info("添加文本内容到阿里云AI请求");
                    Map<String, Object> textContent = new HashMap<>();
                    textContent.put("type", "text");
                    textContent.put("text", message);
                    contentArray.add(textContent);
                }
                
                // 添加图片内容（注意：阿里云要求image_url格式）
                Map<String, Object> imageContent = new HashMap<>();
                imageContent.put("type", "image_url");
                Map<String, Object> imageUrlMap = new HashMap<>();
                imageUrlMap.put("url", imageUrl);
                // 阿里云可能需要detail参数
                imageUrlMap.put("detail", "auto");
                imageContent.put("image_url", imageUrlMap);
                contentArray.add(imageContent);
                
                userMessage.put("content", contentArray);
                messages.add(userMessage);
            } else {
                // 仅添加文本内容
                if (message != null && !message.isEmpty()) {
                    log.info("添加文本内容到阿里云AI请求");
                    Map<String, Object> userMessage = new HashMap<>();
                    userMessage.put("role", "user");
                    userMessage.put("content", message);
                    messages.add(userMessage);
                }
            }
            
            requestBody.put("messages", messages);
            
            // 启用联网搜索功能 - 根据阿里云文档，enable_search需要放在请求体顶层
            requestBody.put("enable_search", true);
            
            // 创建HTTP头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("Authorization", "Bearer " + aliyunApiKey);
            headers.set("X-DashScope-SSE", "disable");
            
            // 创建HTTP实体
            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
            
            // 发送POST请求
            ResponseEntity<Map> response = restTemplate.postForEntity(aliyunApiUrl, entity, Map.class);
            
            // 处理响应
            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
                Map<String, Object> responseBody = response.getBody();
                log.info("阿里云AI响应: {}", responseBody);
                
                // 提取AI回复内容 - 根据实际日志中的响应格式处理
                if (responseBody.containsKey("choices")) {
                    // 兼容模式响应格式（根据您的日志，这是实际返回的格式）
                    List<Map<String, Object>> choices = (List<Map<String, Object>>) responseBody.get("choices");
                    if (choices != null && !choices.isEmpty()) {
                        Map<String, Object> firstChoice = choices.get(0);
                        // 根据您的日志，这里应该直接获取message对象，然后从中提取content
                        if (firstChoice.containsKey("message")) {
                            Map<String, Object> messageObj = (Map<String, Object>) firstChoice.get("message");
                            if (messageObj != null && messageObj.containsKey("content")) {
                                Object content = messageObj.get("content");
                                if (content != null) {
                                    return content.toString();
                                }
                            }
                        }
                        // 如果message不存在，尝试直接获取content（备用方案）
                        else if (firstChoice.containsKey("content")) {
                            Object content = firstChoice.get("content");
                            if (content != null) {
                                return content.toString();
                            }
                        }
                    }
                }
                // 备用处理方式（如果choices不存在）
                else if (responseBody.containsKey("output")) {
                    Map<String, Object> output = (Map<String, Object>) responseBody.get("output");
                    if (output != null) {
                        List<Map<String, Object>> choices = (List<Map<String, Object>>) output.get("choices");
                        if (choices != null && !choices.isEmpty()) {
                            Map<String, Object> firstChoice = choices.get(0);
                            Object messageObj = firstChoice.get("message");
                            if (messageObj != null) {
                                Map<String, Object> messageMap = (Map<String, Object>) messageObj;
                                Object content = messageMap.get("content");
                                if (content != null) {
                                    return content.toString();
                                }
                            }
                        }
                    }
                }
            }
            
            return "AI助手暂时无法提供回复，请稍后重试。";
        } catch (Exception e) {
            log.error("调用阿里云AI接口异常: ", e);
            return "阿里云AI助手暂时无法提供回复，请稍后重试。";
        }
    }
}